Cream of the Crop 3/Cream of the Crop 3.iso/science/ack3d.zip/ACKLDBMP.C

Text File | 1994-01-09 | 6KB | 210 lines

/******************* ( Animation Construction Kit 3D ) ***********************/
/*              Load Bitmap Routines                     */
/* CopyRight (c) 1993       Author: Lary Myers                     */
/*****************************************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <mem.h>
#include <alloc.h>
#include <io.h>
#include <fcntl.h>
#include <time.h>
#include <string.h>
#include <sys\stat.h>
#include "ack3d.h"
#include "ackeng.h"
#include "ackext.h"
#include "xmslib.h"

char *GetExtent(char *s);
UCHAR far *AckReadiff(char *s);

/****************************************************************************
** The application should call this routine to load a bitmap into either   **
** real or XMS memory.                               **
**                                       **
** BitmapNumber is the index number to place the file into.           **
** BitmapType is either TYPE_WALL or TYPE_OBJECT               **
** BitmapName is the filename of the bitmap to load.               **
**                                       **
** Bitmaps used by the ACK engine are 64x64 in size and may be either raw  **
** image (.IMG) files or Deluxe Paint brushes (.BBM) files.           **
**                                       **
****************************************************************************/
int AckLoadBitmap(ACKENG *ae,int BitmapNumber,int BitmapType,char *BitmapName)
{
    int        handle,bFlag;
    int        x,y;
    int        sPos,dPos;
    unsigned char ch;
    XMSHANDLE      xPtr;
    UCHAR    far  *buf;
    UCHAR    far  *bmp;

bFlag = 0;

if (!(stricmp(GetExtent(BitmapName),"BBM")))
    {
    buf = AckReadiff(BitmapName);
    if (buf == NULL)
    return(ERR_LOADINGBITMAP);

    memmove(buf,&buf[4],BITMAP_SIZE);
    bFlag = 1;
    }
else
    {
    buf = malloc(BITMAP_SIZE);
    if (buf == NULL)
    return(ERR_NOMEMORY);
    }

bmp = malloc(BITMAP_SIZE);
if (bmp == NULL)
    {
    free(buf);
    return(ERR_NOMEMORY);
    }

if (BitmapType == TYPE_WALL)
    ae->bMaps[BitmapNumber] = bmp;

if (BitmapType == TYPE_OBJECT)
    ae->oMaps[BitmapNumber] = bmp;

if (!bFlag)
    {
    handle = open(BitmapName,O_RDWR|O_BINARY);
    if (handle < 1)
    {
    free(buf);
    free(bmp);
    return(ERR_BADFILE);
    }

    read(handle,buf,4);        /* Skip width and height for now */
    read(handle,buf,BITMAP_SIZE);
    close(handle);
    }

for (y = 0; y < BITMAP_HEIGHT; y++)
    {
    sPos = y;
    dPos = y * BITMAP_WIDTH;
    for (x = 0; x < BITMAP_WIDTH; x++)
    {
    ch = buf[sPos];
    bmp[dPos++] = ch;
    sPos += BITMAP_WIDTH;
    }
    }

#if USE_XMS
    if (UseXMS > 0)
    {
    xPtr = XMSalloc(BITMAP_SIZE);
    if (xPtr != XMSHNULL)
        {
        if (BitmapType == TYPE_WALL)
        ae->bMaps[BitmapNumber] = (UCHAR far *)xPtr;
        else
        ae->oMaps[BitmapNumber] = (UCHAR far *)xPtr;

        XMSput(xPtr,bmp,BITMAP_SIZE);
        free(bmp);
        }
    }
#endif

free(buf);
return(0);
}

/****************************************************************************
** Internal routine to get the file extent from a filename.           **
**                                       **
****************************************************************************/
char *GetExtent(char *s)
{
    char    *e;

e = strchr(s,'.');
if (e == NULL)
    return(s);
e++;

return(e);
}


/****************************************************************************
** Simplified call to load a wall bitmap.                   **
**                                       **
****************************************************************************/
int AckLoadWall(ACKENG *ae,int WallNumber,char *bmFileName)
{

return( AckLoadBitmap(ae,WallNumber,TYPE_WALL,bmFileName) );
}


/****************************************************************************
** Simplified call to load an object bitmap.                   **
**                                       **
****************************************************************************/
int AckLoadObject(ACKENG *ae,int BmpNumber,char *bmFileName)
{

return( AckLoadBitmap(ae,BmpNumber,TYPE_OBJECT,bmFileName) );
}


/****************************************************************************
** The application should make this call to perform the necessary setup on **
** an object.                                   **
**                                       **
** ObjNumber is the object index                       **
** NumBitmaps is the total number of bitmaps that the object has (min 1).  **
** bmNums is a char array of the bitmap numbers the object uses.       **
**                                       **
** If an object has more than 1 bitmap and the OF_ANIMATE flag is NOT set  **
** then it is assumed the object has more than one side and will be seen   **
** from various angles. If the OF_ANIMATE flag IS set then the object will **
** animate through the multiple bitmaps in the supplied list.           **
**                                       **
****************************************************************************/
int AckCreateObject(ACKENG *ae,int ObjNumber,int NumBitmaps,UCHAR *bmNums)
{
    int        i;


if (NumBitmaps >= MAX_VIEWS)
    return(ERR_TOMANYVIEWS);

if (!NumBitmaps)    /* Force to at least one bitmap */
    NumBitmaps++;

/* Setup index to which bitmap is displayed */
ae->ObjList[ObjNumber].CurNum = 0;
ae->ObjList[ObjNumber].MaxNum = NumBitmaps - 1;

/* Keep the maximum number current */
if (ObjNumber >= ae->MaxObjects && ObjNumber < MAX_OBJECTS)
    ae->MaxObjects = ObjNumber + 1;

/* Calculate sides if a multi-sided object */
ae->ObjList[ObjNumber].Sides = 0;
if (NumBitmaps > 1 && !(ae->ObjList[ObjNumber].Flags & OF_ANIMATE))
    ae->ObjList[ObjNumber].Sides = INT_ANGLE_360 / NumBitmaps;

/* Transfer bitmap numbers to object structure */
for (i = 0; i < NumBitmaps; i++)
    ae->ObjList[ObjNumber].bmNum[i] = bmNums[i];


return(0);
}